home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / kant-generator-04-c / Kant ƒ / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  11.3 KB  |  506 lines  |  [TEXT/MMCC]
  1. #include "menus.h"
  2. #include "graphics.h"
  3. #include "help.h"
  4. #include "environment.h"
  5. #include "print meat.h"
  6. #include "program globals.h"
  7. #include "kant main window.h"
  8. #include "kant load-save.h"
  9. #include "kant text twiddling.h"
  10. //#include "kant search.h"
  11. #include "kant.h"
  12.  
  13. static    MenuHandle        gAppleMenu;
  14. static    MenuHandle        gFileMenu;
  15. static    MenuHandle        gEditMenu;
  16. static    MenuHandle        gOptionsMenu;
  17. static    MenuHandle        gInsertMenu;
  18. //static    MenuHandle        gFindMenu;
  19. static    MenuHandle        gSpeedMenu;
  20. static    Boolean            gMenuEnabled;
  21.  
  22. enum
  23. {
  24.     speedMenu = 200,
  25.     
  26.     appleMenu = 400, fileMenu, editMenu, optionsMenu, insertMenu, findMenu,
  27.     
  28.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  29.     
  30.     newItem = 1, openItem, file_unused1, closeItem, saveItem, saveAsItem, file_unused2,
  31.         pageSetupItem, printItem, file_unused3, quitItem,
  32.     
  33.     undoItem = 1, edit_unused1, cutItem, copyItem, pasteItem, clearItem, edit_unused2,
  34.         selectAllItem,
  35.     
  36.     resolveItem = 1, alwaysResolveItem, option_unused1, option_unused2, option_unused3,
  37.         kantinuousItem,
  38.     
  39.     sectionItem = 1, paragraphItem, sentenceItem, mainClauseItem, introClauseItem,
  40.         throwawayClauseItem, proofItem, throwawaySentenceItem,
  41.     
  42. //    findItem = 1, findAgainItem, enterSelectionItem, replaceItem, replaceAndNextItem,
  43. //        findSelectionItem,
  44.     
  45.     delay0Item = 1, delay6Item, delay12Item, delay30Item, delay60Item
  46. };
  47.  
  48. /*-----------------------------------------------------------------------------------*/
  49. /* internal stuff for menus.c                                                        */
  50.  
  51. static    void HandleAppleMenu(short menuItem);
  52. static    void HandleFileMenu(short menuItem);
  53. static    void HandleEditMenu(short menuItem);
  54. static    void HandleHelpMenu(void);
  55. static    void HandleOptionsMenu(short menuItem);
  56. static    void HandleInsertMenu(short menuItem);
  57. //static    void HandleFindMenu(short menuItem);
  58. static    void HandleSpeedMenu(short menuItem);
  59.  
  60. Boolean InitTheMenus(void)
  61. {
  62.     Handle            MBARHandle;
  63.     
  64.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  65.         return FALSE;
  66.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  67.     
  68.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  69.         return FALSE;
  70.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  71.         return FALSE;
  72.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  73.         return FALSE;
  74.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  75.         return FALSE;
  76.     if ((gInsertMenu=GetMHandle(insertMenu))==0L)
  77.         return FALSE;
  78. //    if ((gFindMenu=GetMHandle(findMenu))==0L)
  79. //        return FALSE;
  80.     if ((gSpeedMenu=GetMenu(speedMenu))==0L)
  81.         return FALSE;
  82.     
  83.     InsertMenu(gSpeedMenu, -1);
  84.     
  85.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  86.     
  87.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  88.     DrawMenuBar();                                /* draws the actual menu bar */
  89.     
  90.     return TRUE;
  91. }
  92.  
  93. void AdjustMenus(void)
  94. {
  95.     WindowPeek        theWindow;
  96.     short            kind;
  97.     long            dummy;
  98.     
  99.     if (gInProgress)
  100.     {
  101.         DisableItem(gAppleMenu, aboutItem);
  102.         DisableItem(gAppleMenu, aboutMSGItem);
  103.         DisableItem(gAppleMenu, helpPointerItem);
  104.         DisableItem(gFileMenu, 0);
  105.         DisableItem(gEditMenu, 0);
  106.         DisableItem(gOptionsMenu, 0);
  107. //        DisableItem(gFindMenu, 0);
  108.         DisableItem(gInsertMenu, 0);
  109.     }
  110.     else
  111.     {
  112.         EnableItem(gAppleMenu, aboutItem);
  113.         EnableItem(gAppleMenu, aboutMSGItem);
  114.         EnableItem(gAppleMenu, helpPointerItem);
  115.         EnableItem(gFileMenu, 0);
  116.         EnableItem(gEditMenu, 0);
  117. //        EnableItem(gFindMenu, 0);
  118.         EnableItem(gOptionsMenu, 0);
  119.         
  120.         theWindow = (WindowPeek)FrontWindow();
  121.         kind = theWindow ? theWindow->windowKind : 0;
  122.         
  123.         if ((kind < 0) ||
  124.             ((theWindow!=0L) && (theWindow==(WindowPeek)GetIndWindowPtr(kMainWindow))))
  125.         {
  126.             EnableItem(gEditMenu, 0);
  127.         }
  128.         else
  129.         {
  130.             DisableItem(gEditMenu, 0);
  131.         }
  132.         
  133.         if (theWindow)
  134.             EnableItem(gFileMenu, closeItem);
  135.         else
  136.             DisableItem(gFileMenu, closeItem);
  137.         
  138.         if (GetIndWindowPtr(kMainWindow))
  139.         {
  140.             DisableItem(gFileMenu, newItem);
  141.             DisableItem(gFileMenu, openItem);
  142.             EnableItem(gFileMenu, saveItem);
  143.             EnableItem(gFileMenu, saveAsItem);
  144.             EnableItem(gFileMenu, printItem);
  145.             EnableItem(gOptionsMenu, resolveItem);
  146.             
  147.             EnableItem(gInsertMenu, 0);
  148.             LoadScrap();
  149.             if (GetScrap(0L, 'TEXT', &dummy)==noTypeErr)
  150.                 DisableItem(gEditMenu, pasteItem);
  151.             else
  152.                 EnableItem(gEditMenu, pasteItem);
  153.             
  154.             if (AnyHighlightedQQ())
  155.             {
  156.                 EnableItem(gEditMenu, cutItem);
  157.                 EnableItem(gEditMenu, copyItem);
  158.                 EnableItem(gEditMenu, clearItem);
  159. //                EnableItem(gFindMenu, enterSelectionItem);
  160. //                EnableItem(gFindMenu, findSelectionItem);
  161.             }
  162.             else
  163.             {
  164.                 DisableItem(gEditMenu, cutItem);
  165.                 DisableItem(gEditMenu, copyItem);
  166.                 DisableItem(gEditMenu, clearItem);
  167. //                DisableItem(gFindMenu, enterSelectionItem);
  168. //                DisableItem(gFindMenu, findSelectionItem);
  169.             }
  170.             
  171.             if (AnyTextQQ())
  172.             {
  173.                 EnableItem(gEditMenu, selectAllItem);
  174.             }
  175.             else
  176.             {
  177.                 DisableItem(gEditMenu, selectAllItem);
  178.             }
  179.             
  180. //            if (AnythingToFindQQ())
  181. //            {
  182. //                EnableItem(gFindMenu, findAgainItem);
  183. //                if (AnythingToReplaceQQ())
  184. //                {
  185. //                    EnableItem(gFindMenu, replaceItem);
  186. //                    EnableItem(gFindMenu, replaceAndNextItem);
  187. //                }
  188. //                else
  189. //                {
  190. //                    DisableItem(gFindMenu, replaceItem);
  191. //                    DisableItem(gFindMenu, replaceAndNextItem);
  192. //                }
  193. //            }
  194. //            else
  195. //            {
  196. //                DisableItem(gFindMenu, findAgainItem);
  197. //                DisableItem(gFindMenu, replaceItem);
  198. //                DisableItem(gFindMenu, replaceAndNextItem);
  199. //            }
  200.             
  201.             DisableItem(gEditMenu, undoItem);
  202.         }
  203.         else
  204.         {
  205.             EnableItem(gFileMenu, newItem);
  206.             EnableItem(gFileMenu, openItem);
  207.             DisableItem(gFileMenu, saveItem);
  208.             DisableItem(gFileMenu, saveAsItem);
  209.             DisableItem(gFileMenu, printItem);
  210.             DisableItem(gOptionsMenu, resolveItem);
  211.             
  212. //            DisableItem(gFindMenu, 0);
  213.             DisableItem(gInsertMenu, 0);
  214.         }
  215.         
  216.         CheckItem(gOptionsMenu, alwaysResolveItem, gAlwaysResolve ? TRUE : FALSE);
  217.         
  218.         CheckItem(gSpeedMenu, delay0Item, (gSpeedDelay==0));
  219.         CheckItem(gSpeedMenu, delay6Item, (gSpeedDelay==6));
  220.         CheckItem(gSpeedMenu, delay12Item, (gSpeedDelay==12));
  221.         CheckItem(gSpeedMenu, delay30Item, (gSpeedDelay==30));
  222.         CheckItem(gSpeedMenu, delay60Item, (gSpeedDelay==60));
  223.     }
  224. }
  225.  
  226. void HandleMenu(long mSelect)
  227. {
  228.     short            menuID = HiWord(mSelect);
  229.     short            menuItem = LoWord(mSelect);
  230.     
  231.     if (mSelect==0L)
  232.     {
  233.         mSelect=LMGetMenuDisable();
  234.         menuID=HiWord(mSelect);
  235.         menuItem=LoWord(mSelect);
  236.         gMenuEnabled=FALSE;
  237.     }
  238.     else gMenuEnabled=TRUE;
  239.     
  240.     LMSetMenuDisable(0L);
  241.     
  242.     switch (menuID)
  243.     {
  244.         case appleMenu:
  245.             HandleAppleMenu(menuItem);
  246.             break;
  247.         case fileMenu:
  248.             HandleFileMenu(menuItem);
  249.             break;    
  250.         case editMenu:
  251.             HandleEditMenu(menuItem);
  252.             break;
  253.         case optionsMenu:
  254.             HandleOptionsMenu(menuItem);
  255.             break;
  256.         case insertMenu:
  257.             HandleInsertMenu(menuItem);
  258.             break;
  259. //        case findMenu:
  260. //            HandleFindMenu(menuItem);
  261. //            break;
  262.         case speedMenu:
  263.             HandleSpeedMenu(menuItem);
  264.             break;
  265.     }
  266. }
  267.  
  268. void DoTheCloseThing(WindowPeek theWindow)
  269. /* a standard close procedure, called when "close" is chosen from File menu and when
  270.    a window is closed through its close box */
  271. {
  272.     Boolean            gotone;
  273.     short            i;
  274.     short            kind;
  275.     
  276.     if (theWindow==0L)
  277.         return;
  278.     
  279.     kind = theWindow ? theWindow->windowKind : 0;
  280.     if (kind<0)        /* DA window or other system window */
  281.         CloseDeskAcc(kind);
  282.     else
  283.     {
  284.         gotone=FALSE;
  285.         /* see if it's one of ours */
  286.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  287.             gotone=((WindowPtr)theWindow==GetIndWindowPtr(i));
  288.         
  289.         if (gotone)        /* if it's one of ours...  see graphics.c */
  290.             CloseTheIndWindow(i-1);            /* this may return FALSE = not closed */
  291.         else
  292.             DisposeWindow((WindowPtr)theWindow);    /* not one of ours, so just close it */
  293.     
  294.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  295.         DrawMenuBar();
  296.     }
  297. }
  298.  
  299. void HandleAppleMenu(short menuItem)
  300. {
  301.     GrafPtr        savePort;
  302.     Str255        name;
  303.     
  304.     if (!gMenuEnabled)
  305.         return;
  306.     if (menuItem==0)
  307.         return;
  308.     
  309.     switch (menuItem)
  310.     {
  311.         case aboutItem:
  312.             OpenTheIndWindow(kAboutWindow);
  313.             break;
  314.         case aboutMSGItem:
  315.             OpenTheIndWindow(kAboutMSGWindow);
  316.             break;
  317.         case helpPointerItem:
  318.             HandleHelpMenu();
  319.             break;
  320.         default:
  321.             if (menuItem > helpPointerItem+1)
  322.             {
  323.                 GetPort(&savePort);
  324.                 GetItem(gAppleMenu, menuItem, name);
  325.                 OpenDeskAcc(name);
  326.                 SetPort(savePort);
  327.             }
  328.             break;
  329.     }
  330. }
  331.  
  332. void HandleFileMenu(short menuItem)
  333. {
  334.     if (!gMenuEnabled)
  335.         return;
  336.     if (menuItem==0)
  337.         return;
  338.     
  339.     switch (menuItem)
  340.     {
  341.         case newItem:
  342.             OpenTheIndWindow(kMainWindow);
  343.             break;
  344.         case openItem:
  345.             LoadSaveDispatch(TRUE, FALSE);
  346.             break;
  347.         case closeItem:
  348.             DoTheCloseThing((WindowPeek)FrontWindow());
  349.             break;
  350.         case saveItem:
  351.             LoadSaveDispatch(FALSE, TRUE);
  352.             break;
  353.         case saveAsItem:
  354.             LoadSaveDispatch(FALSE, FALSE);
  355.             break;
  356.         case pageSetupItem:
  357.             DoThePageSetup();
  358.             break;
  359.         case printItem:
  360.             PrintText(GetTheTextHandle());
  361.             break;
  362.         case quitItem:
  363.             gDone = TRUE;
  364.             break;
  365.     }
  366. }
  367.  
  368. void HandleEditMenu(short menuItem)
  369. {
  370.     if (!gMenuEnabled)
  371.         return;
  372.     if (menuItem==0)
  373.         return;
  374.     
  375.     if (gFrontWindowIsOurs)
  376.     {
  377.         switch (menuItem)
  378.         {
  379.             case undoItem:        CallIndDispatchProc(gFrontWindowIndex, kUndo, 0L);    break;
  380.             case cutItem:        CallIndDispatchProc(gFrontWindowIndex, kCut, 0L);    break;
  381.             case copyItem:        CallIndDispatchProc(gFrontWindowIndex, kCopy, 0L);    break;
  382.             case pasteItem:        CallIndDispatchProc(gFrontWindowIndex, kPaste, 0L);    break;
  383.             case clearItem:        CallIndDispatchProc(gFrontWindowIndex, kClear, 0L);    break;
  384.             case selectAllItem:    CallIndDispatchProc(gFrontWindowIndex, kSelectAll, 0L);    break;
  385.         }
  386.     }
  387.     else SystemEdit(menuItem-1);
  388. }
  389.  
  390. void HandleOptionsMenu(short menuItem)
  391. {
  392.     if (!gMenuEnabled)
  393.         return;
  394.     if (menuItem==0)
  395.         return;
  396.     
  397.     switch (menuItem)
  398.     {
  399.         case resolveItem:
  400.             ParserDispatch((WindowDataHandle)GetWindowDataHandle(kMainWindow));
  401.             break;
  402.         case alwaysResolveItem:
  403.             gAlwaysResolve=!gAlwaysResolve;
  404.             AdjustMenus();
  405.             break;
  406.         case kantinuousItem:
  407.             Kantinuous();
  408.             break;
  409.     }
  410. }
  411.  
  412. void HandleHelpMenu(void)
  413. {
  414.     OpenTheIndWindow(kHelpWindow);
  415. }
  416.  
  417. void HandleInsertMenu(short menuItem)
  418. {
  419.     if (!gMenuEnabled)
  420.         return;
  421.     if (menuItem==0)
  422.         return;
  423.     
  424.     if (FrontWindow()!=GetIndWindowPtr(kMainWindow))
  425.         SelectWindow(GetIndWindowPtr(kMainWindow));
  426.     
  427.     switch (menuItem)
  428.     {
  429.         case sectionItem:
  430.             InsertTheText("\p§ion");
  431.             break;
  432.         case paragraphItem:
  433.             InsertTheText("\p¶graph");
  434.             break;
  435.         case sentenceItem:
  436.             InsertTheText("\p&sentence");
  437.             break;
  438.         case mainClauseItem:
  439.             InsertTheText("\p&main-clause");
  440.             break;
  441.         case introClauseItem:
  442.             InsertTheText("\p&intro-clause");
  443.             break;
  444.         case throwawayClauseItem:
  445.             InsertTheText("\p&throwaway-clause");
  446.             break;
  447.         case proofItem:
  448.             InsertTheText("\p&proof");
  449.             break;
  450.         case throwawaySentenceItem:
  451.             InsertTheText("\p&throwaway-sentence");
  452.             break;
  453.     }
  454.     
  455.     if (gAlwaysResolve)
  456.         ParserDispatch((WindowDataHandle)GetWindowDataHandle(kMainWindow));
  457. }
  458.  
  459. //void HandleFindMenu(short menuItem)
  460. //{
  461. //    if (!gMenuEnabled)
  462. //        return;
  463. //    if (menuItem==0)
  464. //        return;
  465. //    
  466. //    switch (menuItem)
  467. //    {
  468. //        case findItem:
  469. //            DoFindDialog();
  470. //            break;
  471. //        case findAgainItem:
  472. //            if (!DoFindAgain())
  473. //                SysBeep(7);
  474. //            break;
  475. //    }
  476. //}
  477.  
  478. void HandleSpeedMenu(short menuItem)
  479. {
  480.     if (!gMenuEnabled)
  481.         return;
  482.     if (menuItem==0)
  483.         return;
  484.     
  485.     switch (menuItem)
  486.     {
  487.         case delay0Item:
  488.             gSpeedDelay=0;
  489.             break;
  490.         case delay6Item:
  491.             gSpeedDelay=6;
  492.             break;
  493.         case delay12Item:
  494.             gSpeedDelay=12;
  495.             break;
  496.         case delay30Item:
  497.             gSpeedDelay=30;
  498.             break;
  499.         case delay60Item:
  500.             gSpeedDelay=60;
  501.             break;
  502.     }
  503.     
  504.     AdjustMenus();
  505. }
  506.